"""Logger类 - 提供日志记录功能"""

import os
import sys
# 修复标准库logging的导入
import importlib.util
import importlib.resources

# 使用sys.modules确保先导入标准库的logging
if 'logging' not in sys.modules:
    import logging
else:
    # 如果logging已经在sys.modules中，重新导入标准库的logging
    import importlib
    logging = importlib.reload(sys.modules['logging'])

# 现在可以安全地访问logging.handlers
RotatingFileHandler = logging.handlers.RotatingFileHandler
TimedRotatingFileHandler = logging.handlers.TimedRotatingFileHandler
import traceback
from datetime import datetime
from typing import Optional, Dict, Any
from pathlib import Path

# 使用rpa_framework命名空间导入
from rpa_framework.config.config_manager import get_config

class Logger:
    """日志记录器类，提供多级别日志记录功能"""
    
    # 日志级别映射
    LEVEL_MAP = {
        'DEBUG': logging.DEBUG,
        'INFO': logging.INFO,
        'WARNING': logging.WARNING,
        'WARN': logging.WARNING,
        'ERROR': logging.ERROR,
        'CRITICAL': logging.CRITICAL
    }
    
    # 全局日志记录器字典
    _loggers: Dict[str, 'Logger'] = {}
    
    def __init__(self, name: str = 'rpa_framework', log_file: Optional[str] = None):
        """初始化日志记录器
        
        Args:
            name: 日志记录器名称
            log_file: 日志文件路径（可选，默认从配置中获取）
        """
        self.name = name
        
        # 获取配置
        config = get_config()
        
        # 创建logger
        self.logger = logging.getLogger(name)
        self.logger.setLevel(logging.DEBUG)  # 设置最低级别，具体输出由handler控制
        
        # 避免重复添加handler
        if self.logger.handlers:
            return
        
        # 创建formatter
        log_format = config.get('logging.format', '%(asctime)s - %(name)s - %(levelname)s - %(message)s')
        date_format = '%Y-%m-%d %H:%M:%S'
        formatter = logging.Formatter(log_format, date_format)
        
        # 配置控制台handler
        console_handler = logging.StreamHandler(sys.stdout)
        console_level = config.get('logging.level', 'INFO')
        console_handler.setLevel(self.LEVEL_MAP.get(console_level.upper(), logging.INFO))
        console_handler.setFormatter(formatter)
        self.logger.addHandler(console_handler)
        
        # 配置文件handler
        log_file_path = log_file or config.get('logging.file', 'robot.log')
        if log_file_path:
            try:
                # 确保日志目录存在
                log_dir = os.path.dirname(log_file_path)
                if log_dir:
                    os.makedirs(log_dir, exist_ok=True)
                
                # 确定使用哪种轮转方式
                max_file_size = config.get('logging.max_file_size', 10485760)  # 默认10MB
                backup_count = config.get('logging.backup_count', 5)
                
                if max_file_size > 0:
                    # 使用大小轮转
                    file_handler = RotatingFileHandler(
                        log_file_path,
                        maxBytes=max_file_size,
                        backupCount=backup_count,
                        encoding='utf-8'
                    )
                else:
                    # 使用时间轮转（每天）
                    file_handler = TimedRotatingFileHandler(
                        log_file_path,
                        when='midnight',
                        interval=1,
                        backupCount=backup_count,
                        encoding='utf-8'
                    )
                
                file_handler.setLevel(self.LEVEL_MAP.get(console_level.upper(), logging.INFO))
                file_handler.setFormatter(formatter)
                self.logger.addHandler(file_handler)
                
            except Exception as e:
                # 如果无法创建文件handler，记录错误到控制台
                print(f"无法创建日志文件handler: {str(e)}")
        
        # 保存到全局字典
        Logger._loggers[name] = self
    
    def debug(self, message: str, **kwargs) -> None:
        """记录调试日志
        
        Args:
            message: 日志消息
            **kwargs: 附加参数
        """
        self._log(logging.DEBUG, message, **kwargs)
    
    def info(self, message: str, **kwargs) -> None:
        """记录信息日志
        
        Args:
            message: 日志消息
            **kwargs: 附加参数
        """
        self._log(logging.INFO, message, **kwargs)
    
    def warning(self, message: str, **kwargs) -> None:
        """记录警告日志
        
        Args:
            message: 日志消息
            **kwargs: 附加参数
        """
        self._log(logging.WARNING, message, **kwargs)
    
    def error(self, message: str, exception: Optional[Exception] = None, **kwargs) -> None:
        """记录错误日志
        
        Args:
            message: 日志消息
            exception: 异常对象（可选）
            **kwargs: 附加参数
        """
        if exception:
            message = f"{message}. 异常: {str(exception)}"
            # 添加异常堆栈信息
            stack_trace = traceback.format_exc()
            self._log(logging.ERROR, message, stack_trace=stack_trace, **kwargs)
        else:
            self._log(logging.ERROR, message, **kwargs)
    
    def critical(self, message: str, exception: Optional[Exception] = None, **kwargs) -> None:
        """记录严重错误日志
        
        Args:
            message: 日志消息
            exception: 异常对象（可选）
            **kwargs: 附加参数
        """
        if exception:
            message = f"{message}. 异常: {str(exception)}"
            # 添加异常堆栈信息
            stack_trace = traceback.format_exc()
            self._log(logging.CRITICAL, message, stack_trace=stack_trace, **kwargs)
        else:
            self._log(logging.CRITICAL, message, **kwargs)
    
    def exception(self, message: str, **kwargs) -> None:
        """记录异常日志（会自动捕获当前异常）
        
        Args:
            message: 日志消息
            **kwargs: 附加参数
        """
        self._log(logging.ERROR, message, exc_info=True, **kwargs)
    
    def success(self, message: str, **kwargs) -> None:
        """记录成功日志（使用INFO级别）
        
        Args:
            message: 日志消息
            **kwargs: 附加参数
        """
        # 添加成功前缀
        success_message = f"[SUCCESS] {message}"
        self._log(logging.INFO, success_message, **kwargs)
    
    def start_task(self, task_name: str, **kwargs) -> None:
        """记录任务开始
        
        Args:
            task_name: 任务名称
            **kwargs: 附加参数
        """
        start_message = f"任务 '{task_name}' 开始执行"
        if kwargs:
            params_str = ', '.join([f"{k}={v}" for k, v in kwargs.items()])
            start_message += f" (参数: {params_str})"
        
        self._log(logging.INFO, start_message)
    
    def end_task(self, task_name: str, success: bool = True, duration: Optional[float] = None, **kwargs) -> None:
        """记录任务结束
        
        Args:
            task_name: 任务名称
            success: 是否成功
            duration: 执行时长（秒）
            **kwargs: 附加参数
        """
        status = "成功" if success else "失败"
        end_message = f"任务 '{task_name}' 执行{status}"
        
        if duration is not None:
            end_message += f", 耗时: {duration:.2f}秒"
        
        if kwargs:
            result_str = ', '.join([f"{k}={v}" for k, v in kwargs.items()])
            end_message += f" (结果: {result_str})"
        
        log_level = logging.INFO if success else logging.ERROR
        self._log(log_level, end_message)
    
    def _log(self, level: int, message: str, exc_info: bool = False, stack_trace: Optional[str] = None, **kwargs) -> None:
        """内部日志记录方法
        
        Args:
            level: 日志级别
            message: 日志消息
            exc_info: 是否包含异常信息
            stack_trace: 堆栈跟踪信息
            **kwargs: 附加参数
        """
        # 处理附加参数
        if kwargs:
            extra_info = ', '.join([f"{k}={v}" for k, v in kwargs.items()])
            message = f"{message} [{extra_info}]"
        
        # 记录日志
        if stack_trace:
            # 先记录消息，再记录堆栈
            self.logger.log(level, message)
            self.logger.log(level, f"堆栈跟踪:\n{stack_trace}")
        else:
            self.logger.log(level, message, exc_info=exc_info)
    
    def set_level(self, level: str) -> None:
        """设置日志级别
        
        Args:
            level: 日志级别字符串
        """
        log_level = self.LEVEL_MAP.get(level.upper(), logging.INFO)
        self.logger.setLevel(log_level)
        
        # 更新所有handler的级别
        for handler in self.logger.handlers:
            handler.setLevel(log_level)
    
    def add_file_handler(self, file_path: str, level: str = 'INFO', 
                        max_size: int = 10485760, backup_count: int = 5) -> None:
        """添加文件handler
        
        Args:
            file_path: 日志文件路径
            level: 日志级别
            max_size: 最大文件大小（字节）
            backup_count: 备份文件数量
        """
        try:
            # 确保目录存在
            log_dir = os.path.dirname(file_path)
            if log_dir:
                os.makedirs(log_dir, exist_ok=True)
            
            # 创建handler
            file_handler = RotatingFileHandler(
                file_path,
                maxBytes=max_size,
                backupCount=backup_count,
                encoding='utf-8'
            )
            
            # 设置级别和格式
            log_level = self.LEVEL_MAP.get(level.upper(), logging.INFO)
            file_handler.setLevel(log_level)
            
            # 获取格式器
            for handler in self.logger.handlers:
                if isinstance(handler, logging.StreamHandler):
                    file_handler.setFormatter(handler.formatter)
                    break
            
            # 添加handler
            self.logger.addHandler(file_handler)
            self.info(f"已添加日志文件handler: {file_path}")
            
        except Exception as e:
            self.error(f"无法添加文件handler: {str(e)}")
    
    def log_screenshot(self, screenshot_path: str, description: str = "") -> None:
        """记录截图信息
        
        Args:
            screenshot_path: 截图文件路径
            description: 截图描述
        """
        message = f"截图已保存: {screenshot_path}"
        if description:
            message += f" - {description}"
        
        self.info(message)
    
    @staticmethod
    def get_logger(name: str) -> 'Logger':
        """获取指定名称的logger实例
        
        Args:
            name: logger名称
            
        Returns:
            Logger实例
        """
        if name not in Logger._loggers:
            Logger._loggers[name] = Logger(name)
        return Logger._loggers[name]
    
    @staticmethod
    def shutdown_all() -> None:
        """关闭所有logger"""
        logging.shutdown()
        Logger._loggers.clear()

# 便捷函数
def get_logger(name: str = 'rpa_framework') -> Logger:
    """获取logger实例的便捷函数
    
    Args:
        name: logger名称
        
    Returns:
        Logger实例
    """
    return Logger.get_logger(name)

# 记录全局日志的便捷函数
def log_debug(message: str, **kwargs) -> None:
    """便捷的调试日志记录函数
    
    Args:
        message: 日志消息
        **kwargs: 附加参数
    """
    get_logger().debug(message, **kwargs)

def log_info(message: str, **kwargs) -> None:
    """便捷的信息日志记录函数
    
    Args:
        message: 日志消息
        **kwargs: 附加参数
    """
    get_logger().info(message, **kwargs)

def log_warning(message: str, **kwargs) -> None:
    """便捷的警告日志记录函数
    
    Args:
        message: 日志消息
        **kwargs: 附加参数
    """
    get_logger().warning(message, **kwargs)

def log_error(message: str, exception: Optional[Exception] = None, **kwargs) -> None:
    """便捷的错误日志记录函数
    
    Args:
        message: 日志消息
        exception: 异常对象
        **kwargs: 附加参数
    """
    get_logger().error(message, exception, **kwargs)

def log_critical(message: str, exception: Optional[Exception] = None, **kwargs) -> None:
    """便捷的严重错误日志记录函数
    
    Args:
        message: 日志消息
        exception: 异常对象
        **kwargs: 附加参数
    """
    get_logger().critical(message, exception, **kwargs)

def log_exception(message: str, **kwargs) -> None:
    """便捷的异常日志记录函数
    
    Args:
        message: 日志消息
        **kwargs: 附加参数
    """
    get_logger().exception(message, **kwargs)

def log_success(message: str, **kwargs) -> None:
    """便捷的成功日志记录函数
    
    Args:
        message: 日志消息
        **kwargs: 附加参数
    """
    get_logger().success(message, **kwargs)

if __name__ == "__main__":
    # 示例用法
    try:
        # 创建logger实例
        logger = Logger("TestLogger")
        
        # 记录不同级别的日志
        logger.debug("这是一条调试日志")
        logger.info("这是一条信息日志")
        logger.warning("这是一条警告日志")
        logger.success("这是一条成功日志")
        
        # 记录错误日志
        try:
            result = 1 / 0
        except Exception as e:
            logger.error("计算错误", exception=e)
        
        # 使用exception方法（会自动捕获当前异常）
        try:
            result = 1 / 0
        except:
            logger.exception("使用exception方法记录异常")
        
        # 记录任务开始和结束
        logger.start_task("测试任务", param1="value1", param2=123)
        # 模拟任务执行
        logger.end_task("测试任务", success=True, duration=2.5, result="completed")
        
        # 测试不同级别的记录器
        child_logger = Logger("TestLogger.Child")
        child_logger.info("这是子logger的日志")
        
        # 测试便捷函数
        log_info("使用便捷函数记录信息")
        log_error("使用便捷函数记录错误")
        
    except Exception as e:
        print(f"示例执行失败: {e}")
        import traceback
        traceback.print_exc()